<?php
/*
<application>PHP ASSERTION UNIT</application>
<version>1.1<</version>
<author>D. Fournier</author>
<e-mail>zenon48@users.sourceforge.net</e-mail>
<copyright>2002 ID EST</copyright>
<license>GPL</license>
<filename>coretest.inc</filename>
<documentation></documentation>
*/
/*static final boolean*/define('DO_ASSERT', 1);
/*static final boolean*/define('DONT_ASSERT', 0);	////*public ASSERT_Tester*/globaly enable the assertions checking
///*static final undefined*/$IS_UNDEFINED;
/*static final boolean*/define('IS_TRUE', 1);		//don't use TRUE
/*static final boolean*/define('IS_FALSE', 0);		//don't use FALSE
/*static final string*/define('IS_STRING', '<\'phpAssertUnit\'>: "PHP" ASSERTION UNIT');	//a tricky string to check quote and tag conversion
/*static final int*/define('IS_ZERO_NUMBER', 0);
/*static final int*/define('IS_NUMBER', 9876);
/*static final int*/define('IS_HEX_NUMBER', 0x01EF);

/*f)void*/function
TEST_core(){
TEST_isNull();
TEST_isNotNull();
TEST_isUndefined();
TEST_isNotUndefined();
TEST_isTrue();
TEST_isFalse();
TEST_isNumber();
TEST_isNotNumber();
TEST_isEqualToString();
TEST_isNotEqualToString();
	//TEST_overloading();
}	//---TEST_core
TEST_core();

/*f)void*/function
TEST_isNull(){
/*public ASSERT_Tester*/global $Assert;
/*string*/$atCall = 'TEST_isNull: ';

$Assert->warn('TEST_isNull: TESTS with NULL');
$Assert->isNull(NULL, DO_ASSERT, $atCall . 'NULL is null');

$Assert->warn('TEST_isNull: TESTS with IS_UNDEFINED');
$Assert->isNull($IS_UNDEFINED, DO_ASSERT, $atCall . 'IS_UNDEFINED is undefined');

$Assert->warn('TEST_isNull: TESTS with IS_TRUE');
$Assert->isNull(IS_TRUE, DO_ASSERT, $atCall . 'IS_TRUE is true');

$Assert->warn('TEST_isNull: TESTS with IS_FALSE');
$Assert->isNull(IS_FALSE, DO_ASSERT, $atCall . 'IS_FALSE is false');

$Assert->warn('TEST_isNull: TESTS with IS_EMPTY_STRING');
$Assert->isNull($IS_EMPTY_STRING, DO_ASSERT, $atCall . 'IS_EMPTY_STRING is ""');

$Assert->warn('TEST_isNull: TESTS with IS_STRING');
$Assert->isNull(IS_STRING, DO_ASSERT, $atCall . 'IS_STRING is ' . IS_STRING);

$Assert->warn('TEST_isNull: TESTS with IS_ZERO_NUMBER');
$Assert->isNull(IS_ZERO_NUMBER, DO_ASSERT, $atCall . 'IS_ZERO_NUMBER is ' . IS_ZERO_NUMBER);

$Assert->warn('TEST_isNull: TESTS with IS_NUMBER');
$Assert->isNull(IS_NUMBER, DO_ASSERT, $atCall . 'IS_NUMBER is ' . IS_NUMBER);

$Assert->warn('TEST_isNull: TESTS with IS_HEX_NUMBER');
$Assert->isNull(IS_HEX_NUMBER, DO_ASSERT, $atCall . 'IS_HEX_NUMBER is ' . IS_HEX_NUMBER);
}	//---TEST_isNull

/*f)void*/function
TEST_isNotNull(){
/*public ASSERT_Tester*/global $Assert;
/*string*/$atCall = 'TEST_isNotNull: ';

$Assert->warn('TEST_isNotNull: TESTS with NULL');
$Assert->isNotNull(NULL, DO_ASSERT, $atCall . 'NULL is null');

$Assert->warn('TEST_isNotNull: TESTS with IS_UNDEFINED');
$Assert->isNotNull($IS_UNDEFINED, DO_ASSERT, $atCall . 'IS_UNDEFINED is undefined');

$Assert->warn('TEST_isNotNull: TESTS with IS_TRUE');
$Assert->isNotNull(IS_TRUE, DO_ASSERT, $atCall . 'IS_TRUE is true');

$Assert->warn('TEST_isNotNull: TESTS with IS_FALSE');
$Assert->isNotNull(IS_FALSE, DO_ASSERT, $atCall . 'IS_FALSE is false');

$Assert->warn('TEST_isNotNull: TESTS with IS_EMPTY_STRING');
$Assert->isNotNull($IS_EMPTY_STRING, DO_ASSERT, $atCall . 'IS_EMPTY_STRING is ""');

$Assert->warn('TEST_isNotNull: TESTS with IS_STRING');
$Assert->isNotNull(IS_STRING, DO_ASSERT, $atCall . 'IS_STRING is ' . IS_STRING);

$Assert->warn('TEST_isNotNull: TESTS with IS_ZERO_NUMBER');
$Assert->isNotNull(IS_ZERO_NUMBER, DO_ASSERT, $atCall . 'IS_ZERO_NUMBER is ' . IS_ZERO_NUMBER);

$Assert->warn('TEST_isNotNull: TESTS with IS_NUMBER');
$Assert->isNotNull(IS_NUMBER, DO_ASSERT, $atCall . 'IS_NUMBER is ' . IS_NUMBER);

$Assert->warn('TEST_isNotNull: TESTS with IS_HEX_NUMBER');
$Assert->isNotNull(IS_HEX_NUMBER, DO_ASSERT, $atCall . 'IS_HEX_NUMBER is ' . IS_HEX_NUMBER);
}	//---TEST_isNotNull

/*f)void*/function
TEST_isUndefined(){
/*public ASSERT_Tester*/global $Assert;
/*string*/$atCall = 'TEST_isUndefined: ';

$Assert->warn('TEST_isUndefined: TESTS with NULL');
$Assert->isUndefined(NULL, DO_ASSERT, $atCall . 'NULL is null');

$Assert->warn('TEST_isUndefined: TESTS with IS_UNDEFINED');
$Assert->isUndefined($IS_UNDEFINED, DO_ASSERT, $atCall . 'IS_UNDEFINED is undefined');

$Assert->warn('TEST_isUndefined: TESTS with IS_TRUE');
$Assert->isUndefined(IS_TRUE, DO_ASSERT, $atCall . 'IS_TRUE is true');

$Assert->warn('TEST_isUndefined: TESTS with IS_FALSE');
$Assert->isUndefined(IS_FALSE, DO_ASSERT, $atCall . 'IS_FALSE is false');

$Assert->warn('TEST_isUndefined: TESTS with IS_EMPTY_STRING');
$Assert->isUndefined($IS_EMPTY_STRING, DO_ASSERT, $atCall . 'IS_EMPTY_STRING is ""');

$Assert->warn('TEST_isUndefined: TESTS with IS_STRING');
$Assert->isUndefined(IS_STRING, DO_ASSERT, $atCall . 'IS_STRING is ' . IS_STRING);

$Assert->warn('TEST_isUndefined: TESTS with IS_ZERO_NUMBER');
$Assert->isUndefined(IS_ZERO_NUMBER, DO_ASSERT, $atCall . 'IS_ZERO_NUMBER is ' . IS_ZERO_NUMBER);

$Assert->warn('TEST_isUndefined: TESTS with IS_NUMBER');
$Assert->isUndefined(IS_NUMBER, DO_ASSERT, $atCall . 'IS_NUMBER is ' . IS_NUMBER);

$Assert->warn('TEST_isUndefined: TESTS with IS_HEX_NUMBER');
$Assert->isUndefined(IS_HEX_NUMBER, DO_ASSERT, $atCall . 'IS_HEX_NUMBER is ' . IS_HEX_NUMBER);
}	//---TEST_isUndefined

/*f)void*/function
TEST_isNotUndefined(){
/*public ASSERT_Tester*/global $Assert;
/*string*/$atCall = 'TEST_isNotUndefined: ';

$Assert->warn('TEST_isNotUndefined: TESTS with NULL');
$Assert->isNotUndefined(NULL, DO_ASSERT, $atCall . 'NULL is null');

$Assert->warn('TEST_isNotUndefined: TESTS with IS_UNDEFINED');
$Assert->isNotUndefined($IS_UNDEFINED, DO_ASSERT, $atCall . 'IS_UNDEFINED is undefined');

$Assert->warn('TEST_isNotUndefined: TESTS with IS_TRUE');
$Assert->isNotUndefined(IS_TRUE, DO_ASSERT, $atCall . 'IS_TRUE is true');

$Assert->warn('TEST_isNotUndefined: TESTS with IS_FALSE');
$Assert->isNotUndefined(IS_FALSE, DO_ASSERT, $atCall . 'IS_FALSE is false');

$Assert->warn('TEST_isNotUndefined: TESTS with IS_EMPTY_STRING');
$Assert->isNotUndefined($IS_EMPTY_STRING, DO_ASSERT, $atCall . 'IS_EMPTY_STRING is ""');

$Assert->warn('TEST_isNotUndefined: TESTS with IS_STRING');
$Assert->isNotUndefined(IS_STRING, DO_ASSERT, $atCall . 'IS_STRING is ' . IS_STRING);

$Assert->warn('TEST_isNotUndefined: TESTS with IS_ZERO_NUMBER');
$Assert->isNotUndefined(IS_ZERO_NUMBER, DO_ASSERT, $atCall . 'IS_ZERO_NUMBER is ' . IS_ZERO_NUMBER);

$Assert->warn('TEST_isNotUndefined: TESTS with IS_NUMBER');
$Assert->isNotUndefined(IS_NUMBER, DO_ASSERT, $atCall . 'IS_NUMBER is ' . IS_NUMBER);

$Assert->warn('TEST_isNotUndefined: TESTS with IS_HEX_NUMBER');
$Assert->isNotUndefined(IS_HEX_NUMBER, DO_ASSERT, $atCall . 'IS_HEX_NUMBER is ' . IS_HEX_NUMBER);
}	//---TEST_isNotUndefined

/*f)void*/function
TEST_isTrue(){
/*public ASSERT_Tester*/global $Assert;
/*string*/$atCall = 'TEST_isTrue: ';

$Assert->warn('TEST_isTrue: TESTS with NULL');
$Assert->isTrue(NULL, DO_ASSERT, $atCall . 'NULL is null');

$Assert->warn('TEST_isTrue: TESTS with IS_UNDEFINED');
$Assert->isTrue($IS_UNDEFINED, DO_ASSERT, $atCall . 'IS_UNDEFINED is undefined');

$Assert->warn('TEST_isTrue: TESTS with IS_TRUE');
$Assert->isTrue(IS_TRUE, DO_ASSERT, $atCall . 'IS_TRUE is true');

$Assert->warn('TEST_isTrue: TESTS with IS_FALSE');
$Assert->isTrue(IS_FALSE, DO_ASSERT, $atCall . 'IS_FALSE is false');

$Assert->warn('TEST_isTrue: TESTS with IS_EMPTY_STRING');
$Assert->isTrue($IS_EMPTY_STRING, DO_ASSERT, $atCall . 'IS_EMPTY_STRING is ""');

$Assert->warn('TEST_isTrue: TESTS with IS_STRING');
$Assert->isTrue(IS_STRING, DO_ASSERT, $atCall . 'IS_STRING is ' . IS_STRING);

$Assert->warn('TEST_isTrue: TESTS with IS_ZERO_NUMBER');
$Assert->isTrue(IS_ZERO_NUMBER, DO_ASSERT, $atCall . 'IS_ZERO_NUMBER is ' . IS_ZERO_NUMBER);

$Assert->warn('TEST_isTrue: TESTS with IS_NUMBER');
$Assert->isTrue(IS_NUMBER, DO_ASSERT, $atCall . 'IS_NUMBER is ' . IS_NUMBER);

$Assert->warn('TEST_isTrue: TESTS with IS_HEX_NUMBER');
$Assert->isTrue(IS_HEX_NUMBER, DO_ASSERT, $atCall . 'IS_HEX_NUMBER is ' . IS_HEX_NUMBER);
}	//---TEST_isTrue

/*f)void*/function
TEST_isFalse(){
/*public ASSERT_Tester*/global $Assert;
/*string*/$atCall = 'TEST_isFalse: ';

$Assert->warn('TEST_isFalse: TESTS with NULL');
$Assert->isFalse(NULL, DO_ASSERT, $atCall . 'NULL is null');

$Assert->warn('TEST_isFalse: TESTS with IS_UNDEFINED');
$Assert->isFalse($IS_UNDEFINED, DO_ASSERT, $atCall . 'IS_UNDEFINED is undefined');

$Assert->warn('TEST_isFalse: TESTS with IS_TRUE');
$Assert->isFalse(IS_TRUE, DO_ASSERT, $atCall . 'IS_TRUE is true');

$Assert->warn('TEST_isFalse: TESTS with IS_FALSE');
$Assert->isFalse(IS_FALSE, DO_ASSERT, $atCall . 'IS_FALSE is false');

$Assert->warn('TEST_isFalse: TESTS with IS_EMPTY_STRING');
$Assert->isFalse($IS_EMPTY_STRING, DO_ASSERT, $atCall . 'IS_EMPTY_STRING is ""');

$Assert->warn('TEST_isFalse: TESTS with IS_STRING');
$Assert->isFalse(IS_STRING, DO_ASSERT, $atCall . 'IS_STRING is ' . IS_STRING);

$Assert->warn('TEST_isFalse: TESTS with IS_ZERO_NUMBER');
$Assert->isFalse(IS_ZERO_NUMBER, DO_ASSERT, $atCall . 'IS_ZERO_NUMBER is ' . IS_ZERO_NUMBER);

$Assert->warn('TEST_isFalse: TESTS with IS_NUMBER');
$Assert->isFalse(IS_NUMBER, DO_ASSERT, $atCall . 'IS_NUMBER is ' . IS_NUMBER);

$Assert->warn('TEST_isFalse: TESTS with IS_HEX_NUMBER');
$Assert->isFalse(IS_HEX_NUMBER, DO_ASSERT, $atCall . 'IS_HEX_NUMBER is ' . IS_HEX_NUMBER);
}	//---TEST_isFalse

/*f)void*/function
TEST_isNumber(){
/*public ASSERT_Tester*/global $Assert;
/*string*/$atCall = 'TEST_isNumber: ';

$Assert->warn('TEST_isNumber: TESTS with NULL');
$Assert->isNumber(NULL, DO_ASSERT, $atCall . 'NULL is null');

$Assert->warn('TEST_isNumber: TESTS with IS_UNDEFINED');
$Assert->isNumber($IS_UNDEFINED, DO_ASSERT, $atCall . 'IS_UNDEFINED is undefined');

$Assert->warn('TEST_isNumber: TESTS with IS_TRUE');
$Assert->isNumber(IS_TRUE, DO_ASSERT, $atCall . 'IS_TRUE is true');

$Assert->warn('TEST_isNumber: TESTS with IS_FALSE');
$Assert->isNumber(IS_FALSE, DO_ASSERT, $atCall . 'IS_FALSE is false');

$Assert->warn('TEST_isNumber: TESTS with IS_EMPTY_STRING');
$Assert->isNumber($IS_EMPTY_STRING, DO_ASSERT, $atCall . 'IS_EMPTY_STRING is ""');

$Assert->warn('TEST_isNumber: TESTS with IS_STRING');
$Assert->isNumber(IS_STRING, DO_ASSERT, $atCall . 'IS_STRING is ' . IS_STRING);

$Assert->warn('TEST_isNumber: TESTS with IS_ZERO_NUMBER');
$Assert->isNumber(IS_ZERO_NUMBER, DO_ASSERT, $atCall . 'IS_ZERO_NUMBER is ' . IS_ZERO_NUMBER);

$Assert->warn('TEST_isNumber: TESTS with IS_NUMBER');
$Assert->isNumber(IS_NUMBER, DO_ASSERT, $atCall . 'IS_NUMBER is ' . IS_NUMBER);

$Assert->warn('TEST_isNumber: TESTS with IS_HEX_NUMBER');
$Assert->isNumber(IS_HEX_NUMBER, DO_ASSERT, $atCall . 'IS_HEX_NUMBER is ' . IS_HEX_NUMBER);
}	//---TEST_isNumber

/*f)void*/function
TEST_isNotNumber(){
/*public ASSERT_Tester*/global $Assert;
/*string*/$atCall = 'TEST_isNotNumber: ';

$Assert->warn('TEST_isNotNumber: TESTS with NULL');
$Assert->isNotNumber(NULL, DO_ASSERT, $atCall . 'NULL is null');

$Assert->warn('TEST_isNotNumber: TESTS with IS_UNDEFINED');
$Assert->isNotNumber($IS_UNDEFINED, DO_ASSERT, $atCall . 'IS_UNDEFINED is undefined');

$Assert->warn('TEST_isNotNumber: TESTS with IS_TRUE');
$Assert->isNotNumber(IS_TRUE, DO_ASSERT, $atCall . 'IS_TRUE is true');

$Assert->warn('TEST_isNotNumber: TESTS with IS_FALSE');
$Assert->isNotNumber(IS_FALSE, DO_ASSERT, $atCall . 'IS_FALSE is false');

$Assert->warn('TEST_isNotNumber: TESTS with IS_EMPTY_STRING');
$Assert->isNotNumber($IS_EMPTY_STRING, DO_ASSERT, $atCall . 'IS_EMPTY_STRING is ""');

$Assert->warn('TEST_isNotNumber: TESTS with IS_STRING');
$Assert->isNotNumber(IS_STRING, DO_ASSERT, $atCall . 'IS_STRING is ' . IS_STRING);

$Assert->warn('TEST_isNotNumber: TESTS with IS_ZERO_NUMBER');
$Assert->isNotNumber(IS_ZERO_NUMBER, DO_ASSERT, $atCall . 'IS_ZERO_NUMBER is ' . IS_ZERO_NUMBER);

$Assert->warn('TEST_isNotNumber: TESTS with IS_NUMBER');
$Assert->isNotNumber(IS_NUMBER, DO_ASSERT, $atCall . 'IS_NUMBER is ' . IS_NUMBER);

$Assert->warn('TEST_isNotNumber: TESTS with IS_HEX_NUMBER');
$Assert->isNotNumber(IS_HEX_NUMBER, DO_ASSERT, $atCall . 'IS_HEX_NUMBER is ' . IS_HEX_NUMBER);
}	//---TEST_isNotNumber

/*f)void*/function
TEST_isEqualToString(){
/*public ASSERT_Tester*/global $Assert;
/*string*/$atCall = 'TEST_isEqualToString: ';

$Assert->warn('TEST_isEqualToString: TESTS with NULL');
$Assert->isEqual(IS_STRING, NULL, DO_ASSERT, $atCall . 'NULL is null');

$Assert->warn('TEST_isEqualToString: TESTS with IS_UNDEFINED');
$Assert->isEqual(IS_STRING, $IS_UNDEFINED, DO_ASSERT, $atCall . 'IS_UNDEFINED is undefined');

$Assert->warn('TEST_isEqualToString: TESTS with IS_TRUE');
$Assert->isEqual(IS_STRING, IS_TRUE, DO_ASSERT, $atCall . 'IS_TRUE is true');

$Assert->warn('TEST_isEqualToString: TESTS with IS_FALSE');
$Assert->isEqual(IS_STRING, IS_FALSE, DO_ASSERT, $atCall . 'IS_FALSE is false');

$Assert->warn('TEST_isEqualToString: TESTS with IS_EMPTY_STRING');
$Assert->isEqual(IS_STRING, IS_EMPTY_STRING, DO_ASSERT, $atCall . 'IS_EMPTY_STRING is ""');

$Assert->warn('TEST_isEqualToString: TESTS with IS_STRING');
$Assert->isEqual(IS_STRING, IS_STRING, DO_ASSERT, $atCall . 'IS_STRING is ' . IS_STRING);

$Assert->warn('TEST_isEqualToString: TESTS with IS_ZERO_NUMBER');
$Assert->isEqual(IS_STRING, IS_ZERO_NUMBER, DO_ASSERT, $atCall . 'IS_ZERO_NUMBER is ' . IS_ZERO_NUMBER);

$Assert->warn('TEST_isEqualToString: TESTS with IS_ZERO_NUMBER');
$Assert->isEqual(IS_STRING, IS_NUMBER, DO_ASSERT, $atCall . 'IS_NUMBER is ' . IS_NUMBER);

$Assert->warn('TEST_isEqualToString: TESTS with IS_HEX_NUMBER');
$Assert->isEqual(IS_STRING, IS_HEX_NUMBER, DO_ASSERT, $atCall . 'IS_HEX_NUMBER is ' . IS_HEX_NUMBER);
}	//---TEST_isEqualToStringToString

/*f)void*/function
TEST_isNotEqualToString(){
/*public ASSERT_Tester*/global $Assert;
/*string*/$atCall = 'TEST_isNotEqualToString: ';

$Assert->warn('TEST_isNotEqualToString: TESTS with NULL');
$Assert->isNotEqual(IS_STRING, NULL, DO_ASSERT, $atCall . 'NULL is null');

$Assert->warn('TEST_isNotEqualToString: TESTS with IS_UNDEFINED');
$Assert->isNotEqual(IS_STRING, $IS_UNDEFINED, DO_ASSERT, $atCall . 'IS_UNDEFINED is undefined');

$Assert->warn('TEST_isNotEqualToString: TESTS with IS_TRUE');
$Assert->isNotEqual(IS_STRING, IS_TRUE, DO_ASSERT, $atCall . 'IS_TRUE is true');

$Assert->warn('TEST_isNotEqualToString: TESTS with IS_FALSE');
$Assert->isNotEqual(IS_STRING, IS_FALSE, DO_ASSERT, $atCall . 'IS_FALSE is false');

$Assert->warn('TEST_isNotEqualToString: TESTS with IS_EMPTY_STRING');
$Assert->isNotEqual(IS_STRING, $IS_EMPTY_STRING, DO_ASSERT, $atCall . 'IS_EMPTY_STRING is ""');

$Assert->warn('TEST_isNotEqualToString: TESTS with IS_STRING');
$Assert->isNotEqual(IS_STRING, IS_STRING, DO_ASSERT, $atCall . 'IS_STRING is ' . IS_STRING);

$Assert->warn('TEST_isNotEqualToString: TESTS with IS_ZERO_NUMBER');
$Assert->isNotEqual(IS_STRING, IS_ZERO_NUMBER, DO_ASSERT, $atCall . 'IS_ZERO_NUMBER is ' . IS_ZERO_NUMBER);

$Assert->warn('TEST_isNotEqualToString: TESTS with IS_NUMBER');
$Assert->isNotEqual(IS_STRING, IS_NUMBER, DO_ASSERT, $atCall . 'IS_NUMBER is ' . IS_NUMBER);

$Assert->warn('TEST_isNotEqualToString: TESTS with IS_HEX_NUMBER');
$Assert->isNotEqual(IS_STRING, IS_HEX_NUMBER, DO_ASSERT, $atCall . 'IS_HEX_NUMBER is ' . IS_HEX_NUMBER);
}	//---TEST_isNotEqualToString

/*f)void*/function
TEST_overloading(){
/*public ASSERT_Tester*/global $Assert;
/*string*/$atCall = 'TEST_overloading: ';

$Assert->warn('TEST_isTrue: TESTS with IS_FALSE -- arg');
$Assert->isTrue(IS_FALSE);

$Assert->warn('TEST_isTrue: TESTS with IS_FALSE -- arg, DO_ASSERT');
$Assert->isTrue(IS_FALSE, DO_ASSERT);

$Assert->warn('TEST_isTrue: TESTS with IS_FALSE -- arg, DONT_ASSERT');
$Assert->isTrue(IS_FALSE, DONT_ASSERT);

$Assert->warn('TEST_isTrue: TESTS with IS_FALSE -- arg, comment');
$Assert->isTrue(IS_FALSE, 'IS_FALSE is false');

$Assert->warn('TEST_isTrue: TESTS with IS_FALSE -- arg, DO_ASSERT, comment');
$Assert->isTrue(IS_FALSE, DO_ASSERT, $atCall . 'IS_FALSE is false');

$Assert->warn('TEST_isEqual: TESTS with IS_FALSE -- arg');
$Assert->isEqual(IS_FALSE, IS_TRUE);

$Assert->warn('TEST_isEqual: TESTS with IS_FALSE -- arg, DO_ASSERT');
$Assert->isEqual(IS_FALSE, IS_TRUE, DO_ASSERT);

$Assert->warn('TEST_isEqual: TESTS with IS_FALSE -- arg, DONT_ASSERT');
$Assert->isEqual(IS_FALSE, IS_TRUE, DONT_ASSERT);

$Assert->warn('TEST_isEqual: TESTS with IS_FALSE -- arg, comment');
$Assert->isEqual(IS_FALSE, IS_TRUE, 'IS_FALSE is equal to IS_TRUE');

$Assert->warn('TEST_isEqual: TESTS with IS_FALSE -- arg, DO_ASSERT, comment');
$Assert->isEqual(IS_FALSE, IS_TRUE, DO_ASSERT, $atCall . 'IS_FALSE is equal to IS_TRUE');


}	//---TEST_overloading

?>

